home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / amivogl-1.03.lzh / vogl / src / vcalls.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-12  |  3.8 KB  |  266 lines
  1. #include "vogl.h"
  2.  
  3. /*
  4.  * Handles all the v4f v3f v2f calls
  5.  */
  6.  
  7.  
  8. /*
  9.  *  vcall
  10.  *
  11.  *    Specify a generic point.
  12.  */
  13. void vcall(
  14.   float vector[],
  15.   int len)
  16. {
  17. Vector    vec;
  18.  
  19. vec[0] = vector[0];
  20. vec[1] = vector[1];
  21. vec[2] = 0.0;
  22. vec[3] = 1.0;
  23.  
  24. if (len == 3) {
  25.     vec[2] = vector[2];
  26.     vec[3] = 1.0;
  27.     }
  28. else if (len == 4) {
  29.     vec[2] = vector[2];
  30.     vec[3] = vector[3];
  31.     }
  32.  
  33. if (vdevice.save) {
  34.     vdevice.savex = vec[V_X];
  35.     vdevice.savey = vec[V_Y];
  36.     vdevice.savez = vec[V_Z];
  37.     } 
  38.  
  39. switch (vdevice.bgnmode) {
  40. case VLINE:
  41.     if (vdevice.save) {
  42.         vdevice.save = 0;
  43.         move(vec[V_X], vec[V_Y], vec[V_Z]);
  44.         break;
  45.         }
  46.  
  47.     draw(vec[V_X], vec[V_Y], vec[V_Z]);
  48.     break;
  49. case VPNT:
  50.     pnt(vec[V_X], vec[V_Y], vec[V_Z]);
  51.     break;
  52. case VCLINE:
  53.     if (vdevice.save) {
  54.         vdevice.save = 0;
  55.         move(vec[V_X], vec[V_Y], vec[V_Z]);
  56.         break;
  57.         }
  58.  
  59.     draw(vec[V_X], vec[V_Y], vec[V_Z]);
  60.     break;
  61. case VPOLY:
  62.     if (vdevice.save) {
  63.         vdevice.save = 0;
  64.         pmv(vec[V_X], vec[V_Y], vec[V_Z]);
  65.         break;
  66.         } 
  67.  
  68.     pdr(vec[V_X], vec[V_Y], vec[V_Z]);
  69.     break;
  70. default:
  71.     move(vec[V_X], vec[V_Y], vec[V_Z]);
  72.     }
  73. }
  74.  
  75. /* ------------------------------------------------------------------------ */
  76.  
  77. /*
  78.  * v4f    
  79.  *     Adds a 4D point to our fake point buffer
  80.  */
  81. void v4f(float vec[4])
  82. {
  83. vcall(vec, 4);
  84. }
  85.  
  86. /* ------------------------------------------------------------------------ */
  87.  
  88. /*
  89.  * v3f    
  90.  *     Adds a 3D point to our fake point buffer
  91.  */
  92. void v3f(float vec[3])
  93. {
  94. vcall(vec, 3);
  95. }
  96.  
  97. /* ------------------------------------------------------------------------ */
  98.  
  99. /*
  100.  * v2f    
  101.  *     Adds a 2D point to our fake point buffer
  102.  */
  103. void v2f(float vec[2])
  104. {
  105. vcall(vec, 2);
  106. }
  107.  
  108. /* ------------------------------------------------------------------------ */
  109.  
  110.  
  111. /*
  112.  * v4d    
  113.  *     Adds a 4D point to our fake point buffer
  114.  */
  115. void v4d(double vec[4])
  116. {
  117. float    v[4];
  118.  
  119. v[0] = vec[0];
  120. v[1] = vec[1];
  121. v[2] = vec[2];
  122. v[3] = vec[3];
  123.  
  124. vcall(v, 4);
  125. }
  126.  
  127. /* ------------------------------------------------------------------------ */
  128.  
  129. /*
  130.  * v3d    
  131.  *     Adds a 3D point to our fake point buffer
  132.  */
  133. void v3d(double vec[3])
  134. {
  135. float    v[3];
  136.  
  137. v[0] = vec[0];
  138. v[1] = vec[1];
  139. v[2] = vec[2];
  140.  
  141. vcall(v, 3);
  142. }
  143.  
  144. /* ------------------------------------------------------------------------ */
  145.  
  146. /*
  147.  * v2d    
  148.  *     Adds a 2D point to our fake point buffer
  149.  */
  150. void v2d(long vec[2])
  151. {
  152. float    v[2];
  153.  
  154. v[0] = vec[0];
  155. v[1] = vec[1];
  156.  
  157. vcall(v, 2);
  158. }
  159.  
  160. /* ------------------------------------------------------------------------ */
  161.  
  162.  
  163.  
  164. /*
  165.  * v4i    
  166.  *     Adds a 4D point to our fake point buffer
  167.  */
  168. void v4i(long vec[4])
  169. {
  170. float    v[4];
  171.  
  172. v[0] = vec[0];
  173. v[1] = vec[1];
  174. v[2] = vec[2];
  175. v[3] = vec[3];
  176.  
  177. vcall(v, 4);
  178. }
  179.  
  180. /* ------------------------------------------------------------------------ */
  181.  
  182. /*
  183.  * v3i    
  184.  *     Adds a 3D point to our fake point buffer
  185.  */
  186. void v3i(long vec[3])
  187. {
  188. float    v[3];
  189.  
  190. v[0] = vec[0];
  191. v[1] = vec[1];
  192. v[2] = vec[2];
  193.  
  194. vcall(v, 3);
  195. }
  196.  
  197. /* ------------------------------------------------------------------------ */
  198.  
  199. /*
  200.  * v2i    
  201.  *     Adds a 2D point to our fake point buffer
  202.  */
  203. void v2i(long vec[2])
  204. {
  205. float    v[2];
  206.  
  207. v[0] = vec[0];
  208. v[1] = vec[1];
  209.  
  210. vcall(v, 2);
  211. }
  212.  
  213. /* ------------------------------------------------------------------------ */
  214.  
  215. /*
  216.  * v4s    
  217.  *     Adds a 4D point to our fake point buffer
  218.  */
  219. void v4s(short vec[4])
  220. {
  221. float    v[4];
  222.  
  223. v[0] = vec[0];
  224. v[1] = vec[1];
  225. v[2] = vec[2];
  226. v[3] = vec[3];
  227.  
  228. vcall(v, 4);
  229. }
  230.  
  231. /* ------------------------------------------------------------------------ */
  232.  
  233. /*
  234.  * v3s    
  235.  *     Adds a 3D point to our fake point buffer
  236.  */
  237. void v3s(short vec[3])
  238. {
  239. float    v[3];
  240.  
  241. v[0] = vec[0];
  242. v[1] = vec[1];
  243. v[2] = vec[2];
  244.  
  245. vcall(v, 3);
  246. }
  247.  
  248. /* ------------------------------------------------------------------------ */
  249.  
  250. /*
  251.  * v2s    
  252.  *     Adds a 2D point to our fake point buffer
  253.  */
  254. void v2s(short vec[2])
  255. {
  256. float    v[2];
  257.  
  258. v[0] = vec[0];
  259. v[1] = vec[1];
  260.  
  261. vcall(v, 2);
  262. }
  263.  
  264. /* ------------------------------------------------------------------------ */
  265.  
  266.